home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / lcppb.zip / LCPPLIB.ZIP / WINDOW.CPP < prev    next >
C/C++ Source or Header  |  1991-07-08  |  12KB  |  325 lines
  1. // window.cpp -- Window class
  2.  
  3. //#include <disp.h>
  4. #include "disp.h"
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include "error.h"
  8. #include "window.h"
  9.  
  10. #define FALSE  0
  11. #define TRUE   1
  12.  
  13. extern disp_numrows;       // Gain access to normally hidden
  14. extern disp_numcols;       //  display package variables.
  15.  
  16. /* -- Define and initialize the static class member field, which
  17. indicates whether the display package has been initialized.  This
  18. variable is global--it is shared by all variables of the cwindow
  19. class. But, because it's declared private to the class, only class
  20. member functions have access to it. */
  21.  
  22. int cwindow::dispInitialized = FALSE;
  23.  
  24. /* -- Private routine (not a member of the cwindow class). Display a
  25. string at an absolute row and column position using the specified
  26. attribute. Limit length of string to len characters. Ideally, this
  27. routine should display all possible ASCII symbols--it should not
  28. respond to control codes such as carriage returns and line feeds. */
  29.  
  30. void putsat(int row, int col, int len, unsigned attr, char *s)
  31. { 
  32.   unsigned char buffer[264];
  33.   int i, j;
  34.  
  35.   if (len == 0) return;
  36.   for (i = 0, j = 0; i < len; i++, j += 2) {
  37.     buffer[j] = s[i];
  38.     buffer[j + 1] = attr;
  39.   }
  40.   disp_pokebox((unsigned *)&buffer, row, col, row, col + len - 1);
  41. }
  42.  
  43. /* -- Program must call the class static startup function to 
  44. initialize the display package (or another display library if porting
  45. the code). Because startup is a static member function, it can access
  46. only static data members of the class. It has no access whatsoever to
  47. other data fields in cwindow class objects. */
  48.  
  49. void cwindow::startup(void)
  50. {
  51.   if (!dispInitialized) {      // If not initialized yet
  52.     disp_open();               //  then initialize display
  53.     disp_hidecursor();         // Turn off system cursor
  54.     dispInitialized = TRUE;    // Set the static flag
  55.   }
  56. }
  57.  
  58. /* -- Program must call the class static shutDown function to
  59. deinitialize the display package. Failure to call this routine could
  60. lead to display problems after the program ends. (This may or may not
  61. be the case after porting the code to a system that doesn't use the
  62. Zortech display package.) */
  63.  
  64. void cwindow::shutDown(void)
  65. {
  66.   if (dispInitialized) {        // If previously initialized:
  67.     disp_move(disp_numrows - 1, 0 ); // Set cursor to bottom row
  68.     disp_showcursor();               // Display cursor
  69.     disp_close();                    // Shut down display package
  70.     dispInitialized = FALSE;         // Reset the static flag
  71.   }
  72. }
  73.  
  74. /* -- Create and return pointer to a buffer for saving text behind
  75. window. Returns NULL if enough memory is not available. */
  76.  
  77. unsigned *cwindow::saveBuf(void)
  78. {
  79. //  return malloc((ws.height * ws.width) * sizeof(unsigned));
  80.   return (unsigned *)malloc((ws.height * ws.width) * sizeof(unsigned));
  81. }
  82.  
  83. /* -- Perform various common initialization steps for all new
  84. windows. Called by all class constructors. Aborts program if window
  85. class startup function was not called, or if the class was shut down.
  86. If you add new constructors to the cwindow class, be sure to call this
  87. routine, or failing that, at least test the dispInitialized flag and
  88. take appropriate actions if the flag is false. */
  89.  
  90. void cwindow::commonInits(void)
  91. {
  92.   if (!dispInitialized)           // Test if display initialized
  93.     error(ERRWININIT);            // Halt or report error if not
  94.   cr = cc = 0;                    // Home logical cursor
  95.   save = NULL;                    // Text behind not saved
  96.   isOpen = FALSE;                 // window is not open
  97.   if (ws.row > disp_numrows - 3)  // Limit smallest window
  98.     ws.row = disp_numrows - 3;    //  to one row, one column
  99.   if (ws.col > disp_numcols - 3)
  100.     ws.col = disp_numcols - 3;
  101.   if (ws.width < 1) ws.width = 1; // window width must be >= 1
  102.   if (ws.height < 1) ws.height = 1; // window height must be >= 1
  103.   wbr = ws.row + ws.height - 1;   // window's bottom row number
  104.   wrc = ws.col + ws.width - 1;    // window's right column number
  105.   wca = ws.wtattr;                // Current attr = normal text
  106.   wtitle = NULL;                  // No window title (yet)
  107. }
  108.  
  109. /* -- Default constructor. Creates full-screen window. The save
  110. pointer is set to NULL, which causes the window not to save the text
  111. behind it. Because the default window is full screen, this saves at
  112. least 4K of memory. */
  113.  
  114. cwindow::cwindow()
  115. {
  116.   ws.row = ws.col = 0;            // Upper left corner
  117.   ws.width = disp_numcols;        // Full width of display
  118.   ws.height = disp_numrows;       // Full height of display
  119.   ws.wtattr = DISP_NORMAL;        // Normal text attribute
  120.   ws.wbattr = DISP_NORMAL;        // Normal border attribute
  121.   ws.whattr = DISP_REVERSEVIDEO;  // Highlight in reverse video
  122.   ws.wtype = 0;                   // Select double-line border
  123.   commonInits();                  // Do other init steps
  124. }
  125.  
  126. /* -- Alternate constructor. Allows sizing window and selecting 
  127. various attributes. Saves text behind window. */
  128.  
  129. cwindow::cwindow(winStruct &ws, const char *title)
  130. {
  131.   cwindow::ws = ws;
  132.   commonInits();
  133.   setTitle(title);
  134.   save = saveBuf();
  135. }
  136.  
  137. /* -- Destructor. Deallocates save-text buffer (if allocated). Note
  138. that it is legal to pass a NULL pointer to free, but it is not okay
  139. to do the same with delete--a minor inconsistency in this version of
  140. C++ that can lead to trouble. Deleting a NULL pointer may cause the
  141. program to crash. */
  142.  
  143. cwindow::~cwindow()
  144. {
  145.   if (isOpen) hideWindow();  // Close window if open
  146.   free(save);                // Dispose save buffer (if any)
  147.   if (wtitle) delete wtitle; // Dispose old title (if any)
  148. }
  149.  
  150. /* -- Display window outline and title if one was assigned. Called
  151. by showWindow and if the title is changed after window is opened. */
  152.  
  153. void cwindow::showOutline(void)
  154. {
  155.   int len;    // String length
  156.  
  157.   disp_box(ws.wtype, ws.wbattr, ws.row, ws.col, wbr, wrc);
  158.   if (wtitle != NULL) {
  159.     len = strlen(wtitle->getString());
  160.     if (len > 0) {
  161.       putsat(ws.row, ws.col + ((ws.width - len) / 2), len,
  162.         ws.wbattr, wtitle->getString());
  163.       gotorc(cr, cc);
  164.     }
  165.   }
  166. }
  167.  
  168. /* -- Save text behind window (optional), draw window's border, erase
  169. the contents. Cursor is positioned inside window at top left corner.
  170. The host program is expected to display the window's contents.
  171. Prevents accidentally opening an already open window, which would
  172. destroy the save buffer. */
  173.  
  174. void cwindow::showWindow()
  175. {
  176.   if (isOpen) return;  // Prevent multiple openings
  177.   if (save) disp_peekbox(save, ws.row, ws.col, wbr, wrc);
  178.   showOutline();
  179.   isOpen = TRUE;
  180.   gotorc(0, 0);
  181.   normalVideo();
  182.   eeow();
  183. }
  184.  
  185. /* -- Restore any saved text behind window and mark window closed. If
  186. there is no save buffer, the display will not change, although the
  187. window will still be closed. */
  188.  
  189. void cwindow::hideWindow()
  190. {
  191.   if (!isOpen) return; // Exit if window is closed
  192.   if (save) disp_pokebox(save, ws.row, ws.col, wbr, wrc);
  193.   isOpen = FALSE;
  194. }
  195.  
  196. /* -- Change window title. You may call this routine whether or not
  197. you specified a title when creating the window object. window may
  198. be open or closed. */
  199.  
  200. void cwindow::setTitle(const char *s)
  201. {
  202.   if (wtitle) delete wtitle;
  203.   wtitle = new strItem(s, ws.width - 2);
  204.   if (isOpen) showOutline();
  205. }
  206.  
  207. /* -- Assign new attributes to window. Use this function to move and
  208. resize windows, or just to change their colors, border types, etc.
  209. Selects normalVideo output. */
  210.  
  211. void cwindow::setInfo(winStruct &ws)
  212. {
  213.   int wasOpen = isOpen;
  214.  
  215.   if (isOpen) hideWindow();
  216.   if (save) delete save;
  217.   cwindow::ws = ws;
  218.   save = saveBuf();
  219.   if (wasOpen) {
  220.     normalVideo();
  221.     showWindow();
  222.   }
  223. }
  224.  
  225. /* -- Move cursor to position inside window border. Top left position
  226. is 0, 0 (home). Row and column values are relative to window
  227. boundaries. Note: Does not make system cursor visible--instead, this
  228. function prepares the location where text will appear for the next
  229. call to puts(). Cursor is allowed to rest on the right border, but
  230. otherwise must remain within the window's boundaries.*/
  231.  
  232. void cwindow::gotorc(int row, int col)
  233. {
  234.   if (!isOpen) return;       // Exit if window is closed
  235.   cr = row; cc = col;        // Save relative values
  236.   if (cc < 0) cc = 0;        // Prevent negative
  237.   if (cr < 0) cr = 0;        //  cursor positions
  238.   if (cc > ws.width - 2)
  239.     cc = ws.width - 2;      // Limit col to window width
  240.   if (cr > ws.height - 3)
  241.     cr = ws.height - 3;     // Limit row to window height
  242.   disp_move(ws.row + cr + 1, ws.col + cc + 1);
  243. }
  244.  
  245. /* -- Display string at current cursor position. String is truncated
  246. to fit within the window boundaries. Cursor is positioned at the end
  247. of the string. (It is possible for the cursor to be on the
  248. right border, but it is not possible to display text there.) */
  249.  
  250. void cwindow::puts(char *s)
  251. {
  252.   int len = strlen(s);          // String length
  253.   int nc = ws.width - cc - 2;   // Number chars right of cursor
  254.  
  255.   if (!isOpen) return;    // Exit if window is closed
  256.   if (nc <= 0) return;    // Exit if no space to cursor's right
  257.   if (len == 0) return;   // Exit if length of string is 0
  258.   if (len > nc) len = nc; // Truncate too-long strings
  259.   putsat(ws.row + cr + 1, ws.col + cc + 1, len, wca, s);
  260.   gotorc(cr, cc + len);   // Position cursor to end of string
  261. }
  262.  
  263. /* -- Scroll contents of current window up by the number of lines 
  264. specified in nrows. Blanks that many lines at bottom using the current
  265. display attribute. */
  266.  
  267. void cwindow::scrollUp(int nrows)
  268. {
  269.   if (!isOpen) return; // Exit if window is closed
  270.   disp_scroll(nrows, ws.row + 1, ws.col + 1, wbr - 1, wrc - 1, wca);
  271. }
  272.  
  273. /* -- Scroll contents of current window down by the number of lines 
  274. specified in nrows. Blanks that many lines at top using the current
  275. display attribute. */
  276.  
  277. void cwindow::scrollDown(int nrows)
  278. {
  279.   if (!isOpen) return; // Exit if window is closed
  280.   disp_scroll(-nrows, ws.row + 1, ws.col + 1, wbr - 1, wrc - 1, wca);
  281. }
  282.  
  283. /* -- Erase from current cursor position to end of line, that is, to
  284. just before the window's right border. Uses the current attribute for
  285. the blanked area. */
  286.  
  287. void cwindow::eeol(void)
  288. {
  289.   unsigned attr = wca * 256 + ' '; // Attribute for blank line
  290.   int nc = ws.width - cc - 3;      // Number of chars to erase
  291.   int acr = ws.row + cr + 1;       // Absolute cursor row
  292.   int acc = ws.col + cc + 1;       // Absolute cursor column
  293.  
  294.   if (!isOpen) return;    // Exit if window is closed
  295.   if (nc < 0) return;     // Exit if no space to cursor's right
  296.   disp_fillbox(attr, acr, acc, acr, acc + nc);
  297. }
  298.  
  299. /* -- Erase from current cursor position to end of window, that is,
  300. to just before the window's bottom border. Uses the current attribute
  301. for the blanked area. */
  302.  
  303. void cwindow::eeow(void)
  304. {
  305.   int ocr = cr;        // Save old cr (cursor row)
  306.   int occ = cc;        // Save old cc (cursor col)
  307.  
  308.   if (!isOpen) return;             // Exit if window is closed
  309.   eeol();                          // Erase to end of current line
  310.   while (++cr < ws.height - 2) {   // Erase other full lines if any
  311.     gotorc(cr, 0);
  312.     eeol();
  313.   }
  314.   cr = ocr;            // Restore saved cursor position
  315.   cc = occ;
  316. }
  317.  
  318.  
  319. // Copyright (c) 1990 by Tom Swan. All rights reserved
  320. // Revision 1.00    Date: 09/22/1990   Time: 12:33 am
  321.  
  322. // Revision 1.01    Date: 07/08/1991   Time: 05:41 pm
  323. // Converted for Borland C++ 2.0
  324.  
  325.